#!/bin/bash
#############################################################
# Ejecutable: postonio.sh												#
#																				#
# Precondiciones: se ejecutó ./postini.sh con anterioridad  #
#																				#
# Para iniciar el demonio usar: "./postonio.sh start"			#
# Para detener el demonio usar: "./postonio.sh stop"			#
#############################################################
clear

# Variables del script

# Contamos con $ARRIDIR y $grupo como variables de ambiente

# Nombre demonio
DEMONIO="postonio.sh"

CARPETA_VALIDADOS=$grupo"/recibidos"
CARPETA_RECHAZADOS=$grupo"/rechazados"
ARCH_AGENCIAS=$grupo"/data/agencias.mae"
ARCH_SEC=$grupo"/data/secuencias.dat"

# Tiempo de espear
SLEEPTIME_SEGS=10

# ERRORES
NOERROR=0
# Error general
ERROR=1
# Errores de archivo
ERROR_FORMATO=2
ERROR_SECUENCIA=3
ERROR_AGENCIA=4

# Mensajes de error
MSG_FORMATO="Formato incorrecto"
MSG_SECUENCIA="Secuencia inválida"
MSG_AGENCIA="Agencia inexistente"

# **** Funciones del script ******
# Comprobar si hay otra instancia corriendo
otraInstanciaCorriendo(){
	# Solo puede haber una instancia corriendo, la actual
	MIPID=$$

	res=`ps -ef | grep $DEMONIO | grep -v $$ | grep -v "grep" | grep -v "$MIPID" | wc -l`

	if [ "$res" -gt 0 ]
	then
		echo "Error: hay otra instancia de $DEMONIO corriendo. Instancias: $res"
		exit 1
	fi
}

# Esta funcion la usamos para aumentar la secuencia de una agencia en el archivo de secuencias
# parametros: codigo agencia ($1), secuencia siguiente ($2)
aumentarSecuencia(){
	local ARCH_AUX=$grupo"/data/aux.dat"
	
	local secuencia=`printf "%06d" "$2"`
	
	# Creamos un archivo auxiliar
	`:> $ARCH_AUX` 
	
	for linea in `cat $ARCH_SEC`;
	do
		res=`echo $linea | grep "^$1"`

		if [ "$res" == "" ]; then
			`echo "$linea" >> $ARCH_AUX`
		else
			`echo "$1:$secuencia" >> $ARCH_AUX`
		fi
	done
	
	# Borramos el archivo anterior
	`rm $ARCH_SEC`
	
	# Reemplazamos con el nuevo archivo de secuencias
	`mv -f $ARCH_AUX $ARCH_SEC`
}

# Funcion para validar el nombre del archivo existente en $ARRIDIR
validar(){
	local nombre="$1"

	# Validamos el formato del nombre del archivo
	local nombreValido=`echo "$nombre" | grep "^[a-zA-Z0-9]\{6\}.[0-9]\{6\}$"`

	if [ $nombreValido ]; then
		local agencia=`echo $nombre |	sed 's/\([a-zA-Z0-9]\{6\}\).\([0-9]\{6\}\)/\1/'`
		local secuencia=`echo $nombre |	sed 's/\([a-zA-Z0-9]\{6\}\).\([0-9]\{6\}\)/\2/'`
		
		# Validamos si existe la agencia
		local agenciaValida=`cut -d, -f2 $ARCH_AGENCIAS |	grep "^$agencia"`

		if [ $agenciaValida  ]; then
			# Validamos el número de secuencia
			local secuenciaActual=`grep "^$agencia" $ARCH_SEC | sed 's/\([0-9]\{6\}\):\([0-9]\{6\}\)/\2/'`
			
			local secuenciaSiguiente=`echo "$secuenciaActual+1" | bc`

			if [ $secuencia -eq $secuenciaSiguiente ]; then
				# El nombre del archivo y la secuencia son válidos, se mueve el archivo.
				aumentarSecuencia $agencia $secuenciaSiguiente
				echo $NOERROR
			else
				#Error: El número de secuencia no es válido.
				echo $ERROR_SECUENCIA
			fi
		else
			#Error: No existe la agencia en el archivo maestro.
			echo $ERROR_AGENCIA
		fi
	else
		#Error: El formato del nombre del archivo no es válido.
		echo $ERROR_FORMATO
	fi
}

# Esta función recorre uno a uno los archivos existentes 
# en el directorio de arribos y valida el nombre
procesoArribos(){
	filecount=$(ls $ARRIDIR | wc -l)
	while [ $filecount -gt 0 ];do
	
		# Obtengo el nombre del primer archivo del directorio			
		primerArchivo=$(ls $ARRIDIR | head -1)
	
		# Validacion del archivo
		valido=`validar $primerArchivo`
		# echo $valido
		
		if [ $valido -eq $NOERROR ];then
			# Si es valido, entonces lo muevo a la carpeta de archivos recibidos
			#Grabarlog				
			`$BINDIR/gralog.sh postonio "Archivo válido: $primerArchivo, se mueve a recibido." I`
			
			#MoverArchivo
			res=`$BINDIR/mover.sh "$ARRIDIR/$primerArchivo" "$CARPETA_VALIDADOS/$primerArchivo"`
		else
			# Si no es valido, lo muevo a la carpeta de archivos rechazados
			
			#Decidimos mensaje de log
			local MSG=""
			case $valido in
				$ERROR_FORMATO) MSG=$MSG_FORMATO
				;;
				$ERROR_SECUENCIA) MSG=$MSG_SECUENCIA
				;;
				$ERROR_AGENCIA) MSG=$MSG_AGENCIA
				;;
				*) MSG="Error no manejado"
			esac 		
			# Grabamos mensaje de log
			`$BINDIR/gralog.sh postonio "Error: $MSG. El archivo $primerArchivo se mueve a rechazados." A`
			

			# Movemos el archivo a rechazados						
			res=`$BINDIR/mover.sh "$ARRIDIR/$primerArchivo" "$CARPETA_RECHAZADOS/$primerArchivo"`
		fi
		filecount=$(ls $ARRIDIR | wc -l)
	done
}

# Función para obtener el id del comando postular
function ObtenerIdPostular(){
        res=0

        IFS_ANT=$IFS
        IFS='
        '

        for i in `ps -A | grep "postular.sh" | cat`
        do
                # Creamos un array con la linea que devuelve el ps
                IFS=$IFS_ANT
                array=( `echo "$i"` )
                id=${array[0]}
                name=${array[3]}

                IFS_ANT=$IFS
                IFS='
                '
                if [ $name = "postular.sh" ]
                then
                        res=$id
                fi
        done
        IFS=$IFS_ANT

        echo $res
}

# Se inicia el comando postular.sh
procesoRecibidos(){
	# Comprobar si postular.sh está en ejecución
   res=`ps -A |grep "postular.sh" |grep -v "grep"| wc -l`
   if [ $res -eq 0 ]; then
   	# Si no está en ejecución lo ejecutamos
   	echo "Ejecutamos el comando postular.sh"
   	# Lo llamamos de la siguiente manera para que 
   	# muestre sus mensajes por salida estandar
   	$BINDIR/postular.sh
   fi
}

comprobarAmbiente(){
	if [ -z $grupo ]
	then
		echo "Error: falta inicializar $grupo ambiente."
		exit 1
	fi
}

start(){
	 # Antes de iniciar el demonio verifico que no haya otro corriendo
    otraInstanciaCorriendo
    comprobarAmbiente
    echo "Iniciando postonio..."
    main
}

stop(){
    echo "Deteniendo postonio..."
    MIPID=$$
	echo "MIPDI:$MIPID:"

	res=`ps -ef | grep $DEMONIO | grep -v "grep" |grep -v $$ | grep -v "$MIPID" | wc -l`
	echo "res:$res:"
    if [ "$res" -gt 0 ]
    then
    	res=`ps -ef |grep $0|grep -v "$MIPID" |grep -v $$ |grep -v "grep"|awk '{print($2)}'`
   	kill "$res"
    fi
}

main(){
	if [ ! -f $ARCH_SEC ]
	then
		echo "Error: falta archivo de secuencias que deberia crear el postini.sh"
		exit 1
	fi
	
	# Loop de proceso del demonio
	echo "Demonio iniciado correctamente. "
	while [ 1 = 1 ]; do

		# ARRIBOS
		# Cantidad de archivos en la carpeta
		filecount=$(ls $ARRIDIR | wc -l)

		# Si la cuenta es mayor a cero entonces hay archivos para ejecutar
		if [ $filecount -gt 0 ]; then
			procesoArribos
		fi
	
		# RECIBIDOS
		# Cantidad de archivos en la carpeta
		filecount=$(ls $CARPETA_VALIDADOS | wc -l)

		# Si la cuenta es mayor a cero entonces hay archivos para ejecutar
		if [ $filecount -gt 0 ]; then
			procesoRecibidos
		fi

		# Tiempo que permanece dormido
		sleep $SLEEPTIME_SEGS
	done
}

####################################################
case $1 in
    "start")
       start
    ;;
    "stop")
        stop
    ;;
     *)
         start
     ;;
esac
####################################################
